Your goal is to generate plan in domain specific language (DSL) for biology protocols.
Two perspectives of the DSL specification are provided: the specification for experimental operations and the specification for experimental products. 
The DSL specification of each operation or product consists of multiple patterns, each pattern is an operation execution paradigm or a product flow paradigm.
Output every operation of the plan in the form of an operation DSL program and every product of the plan in the form of a product DSL program.
Each DSL program is a dictionary. The final plan consists of the program of each step and product and is returned in a json block, without any annotation.

This is the format of a product-view DSL program：
// Each product view DSL program represents the state of the product at that moment.
{
    Pred: <Operation>,      // Pred represents the operation that precedes the creation of this product，need to align to the operation name in the operation view DSL program. If the product is in its initial state, return "".
    FlowUnit: {     // FlowUnit defines the properties of the product being processed.
        Component: ,    // Component represents the actual product or material being processed， need to be the formal name of the component.
        ComponentType: Gas|Liquid|Solid|Semi-Solid|Mixture|ChemicalCompound|BiologicalMaterial|Reagent|PhysicalObject|File/Data,        // ComponentType describes the type of the component, which can be one of the following: Gas, Liquid, Solid, Semi-Solid, Mixture, ChemicalCompound, BiologicalMaterial, Reagent, PhysicalObject, or File/Data.
        RefName: ,      // RefName is the reference name used to uniquely identify this component, need to align to the operation-view program
        UnitArgType: MAT | PROD,    // UnitArgType specifies whether this is a material (MAT) or a product (PROD).
        Vol: ,      // Vol represents the volume or quantity of the component.
        Container: ,    // Container indicates the type of container or storage used for this component. If the product has no container constraints in its current state, return "".
        Cond: {         // Cond defines the specific conditions under which the operation is carried out, which is expressed as key-value pairs.
            ArgKey: ArgValues
        }
    },
    Succ: <Operation>      // Succ represents the operation that follows the creation of this product. If the product is in its final state, return "".
}

This is the format of an operation-view DSL program：
// Each operation view DSL program represents a sequence of operations that alters the state of the product.
{
    Operation: ,    // Operation verb
    Precond: {      // Precondition
        SlotArgNum: ,   // Number of arguments for the precondition
        SlotArg:        // SlotArg represents the input product or material required for this operation, using formal component names from the product perspective DSL program, with serial numbers to distinguish repeated components in different states.
    },
    Execution: {
        DeviceType: ,   // Execution device for the operation
        Config: {       // dict of execution arguments - values
            ArgKey: ArgValues  
        }
    },
    Postcond: {     // Postcondition
        EmitArgNum: ,    // Number of arguments for the postcondition
        EmitArg:        // EmitArg represents the output product or material resulting from the operation, using formal component names from the product perspective DSL program, with serial numbers to distinguish repeated components in different states.
    }
}

Here is an example of how to generate plan in DSL for a biology protocol.

EXAMPLE:

DNA extraction from avian faeces stored in ethanol

Here are some extra details about the protocol:

This molecular biology protocol aims to extract DNA from blue tit (Cyanistes caeruleus) faeces stored in ethanol using the Qiagen QIAamp DNA Stool Kit with custom modifications. These modifications include homogenization in lysis buffer, increased lysis times with additional Proteinase K, and larger buffer volumes to improve DNA yields.

The part of the plan starting from the beginning in natural language:

1. Pour 100 mL of 1X TAE Buffer into an Erlenmeyer Flask. 
2. Weigh out 1 g Agarose and add it to the Erlenmeyer Flask. 
3. Place Erlenmeyer Flask in a microwave on high power for two minutes or until solution is clear and agarose is completely dissolved, occasionally stirring. 

The part of the plan starting from the beginning in the form of DSL program:
```json
[
    {
        "Pred": "",
        "FlowUnit": {
            "Component": "1X TAE Buffer",
            "ComponentType": "Liquid",
            "RefName": "TAE_Buffer-1",
            "UnitArgType": "MAT",
            "Vol": "100 mL",
            "Container": "",
            "Cond": {
                "State": "Liquid",
                "Purity": "1X"
            }
        },
        "Succ": "Pour"
    },
    {
        "Operation": "Pour",
        "Precond": {
            "SlotArgNum": 1,
            "SlotArg": ["TAE_Buffer-1"]
        },
        "Execution": {
            "DeviceType": "Erlenmeyer Flask",
            "Config": {
                "Volume": "100mL"
            }
        },
        "Postcond": {
            "EmitArgNum": 1,
            "EmitArg": ["TAE_Buffer-2"]
        }
    },
    {
        "Pred": "Pour",
        "FlowUnit": {
            "Component": "1X TAE Buffer",
            "ComponentType": "Liquid",
            "RefName": "TAE_Buffer-2",
            "UnitArgType": "PROD",
            "Vol": "100 mL",
            "Container": "Erlenmeyer Flask",
            "Cond": {
                "State": "Liquid",
                "Purity": "1X"
            }
        },
        "Succ": ""
    },
    {
        "Pred": "",
        "FlowUnit": {
            "Component": "Agarose",
            "ComponentType": "Solid",
            "RefName": "Agarose-1",
            "UnitArgType": "MAT",
            "Vol": "1 g",
            "Container": "",
            "Cond": {
                "State": "Solid"
            }
        },
        "Succ": "Add"
    }
    {
        "Operation": "Add",
        "Precond": {
            "SlotArgNum": 2,
            "SlotArg": ["Agarose-1", "TAE_Buffer-2"]
        },
        "Execution": {
            "DeviceType": "Erlenmeyer Flask",
            "Config": {
                "Volume": "100mL"
            }
        },
        "Postcond": {
            "EmitArgNum": 1,
            "EmitArg": ["Agarose_TAE_Buffer-1"]
        }
    },
    {
        "Pred": "",
        "FlowUnit": {
            "Component": "Agarose in TAE Buffer",
            "ComponentType": "Mixture",
            "RefName": "Agarose_TAE_Buffer-1",
            "UnitArgType": "PROD",
            "Vol": "100 mL",
            "Container": "Erlenmeyer Flask",
            "Cond": {
                "State": "Solid-Liquid Mixture",
                "Temperature": "High"
            }
        },
        "Succ": "Place"
    }
]
```

[Requirements]
1. Design the experiment with finer granularity, incorporating more steps to complete the experiment in a more rigorous, complex, and comprehensive manner.
2. There are some missing parameters in the DSL specification. You should generate each step of the DSL program as detailed as possible based on your understanding of the protocol plan.

YOUR TASK:
Generate plan in DSL for a protocol for {title}.

Here are some extra details about the protocol:

{details}

You can choose to instantiate the following DSL specifications to construct the DSL program:

Operation-view DSL specification:
{Operation-DSL}

Product-view DSL specification:
{Product-DSL}

Your plan in DSL program: